home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 79 / maccd 79.iso / multimedial / GL Tron / Source / gltron / engine.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-20  |  8.0 KB  |  319 lines  |  [TEXT/CWIE]
  1. #include "gltron.h"
  2.  
  3. int getCol(int x, int y) {
  4.   if(x < 0 || x >= game->settings->grid_size -1 ||
  5.      y < 0 || y >= game->settings->grid_size -1 ||
  6.      colmap[ y * colwidth + x ] != 0)
  7.     return 1;
  8.   else return 0;
  9. }
  10.  
  11. void initGameStructures() { /* called only once */
  12.   /* default art names */
  13.   char artpack_name[] = "TRON style";
  14.   char artpack_path[] = "default";
  15.   /* init game screen */
  16.   /* init players. for each player: */
  17.   /*   init model */
  18.   /*   init display */
  19.   /*   init ai */
  20.   /*   create data */
  21.   /*     create trails */
  22.   /*   create camera */
  23.  
  24.   gDisplay *d;
  25.   int i;
  26.   /* int onScreen; */
  27.   /* Data *data; */
  28.   /* Camera *c; */
  29.   /* Model *m; */
  30.   AI *ai;
  31.   Player *p;
  32.  
  33.   game->winner = -1;
  34.   game->screen = (gDisplay*) malloc(sizeof(gDisplay));
  35.   d = game->screen;
  36.   d->h = game->settings->height; d->w = game->settings->width;
  37.   d->vp_x = 0; d->vp_y = 0;
  38.   d->vp_w = d->w; d->vp_h = d->h;
  39.   d->blending = 1;
  40.   d->fog = 0;
  41.   d->shademodel = GL_SMOOTH;
  42.   d->wall = 1;
  43.   d->onScreen = -1;
  44.   d->textures = (unsigned int*) malloc(game_textures * sizeof(unsigned int));
  45.  
  46.   // TODO: change that
  47.   d->artpack.name = malloc(sizeof(artpack_name));
  48.   memcpy(d->artpack.name, artpack_name, sizeof(artpack_name));
  49.   d->artpack.path = malloc(sizeof(artpack_path));
  50.   memcpy(d->artpack.path, artpack_path, sizeof(artpack_path));
  51.  
  52.   game->players = PLAYERS;
  53.   game->player = (Player *) malloc(MAX_PLAYERS * sizeof(Player));
  54.   for(i = 0; i < game->players; i++) {
  55.     p = (game->player + i);
  56.     p->model = (Model*) malloc(sizeof(Model));
  57.     p->display = (gDisplay*) malloc(sizeof(gDisplay));
  58.     p->ai = (AI*) malloc(sizeof(AI));
  59.     p->data = (Data*) malloc(sizeof(Data));
  60.     p->data->trails = (line*) malloc(MAX_TRAIL * sizeof(line));
  61.     p->camera = (Camera*) malloc(sizeof(Camera));
  62.  
  63.     /* init model & display & ai */
  64.     initModel(p, i);
  65.  
  66.     ai = p->ai;
  67.     if(game->settings->screenSaver) {
  68.       ai->active = AI_COMPUTER;
  69.     } else {
  70.       switch(i) {
  71.       case 0: ai->active = game->settings->ai_player1; break;
  72.       case 1: ai->active = game->settings->ai_player2; break;
  73.       case 2: ai->active = game->settings->ai_player3; break;
  74.       case 3: ai->active = game->settings->ai_player4; break;
  75.       default:
  76.     fprintf(stderr, "player index #%d not caught!\n", i);
  77.     ai->active = AI_NONE;
  78.       }
  79.     }
  80.     ai->tdiff = 0;
  81.     ai->moves = 0;
  82.     ai->danger = 0;
  83.     ai->lastx = 0;
  84.     ai->lasty = 0;
  85.   }
  86.  
  87.   changeDisplay();
  88.  
  89.   game2->events.next = NULL;
  90.   game2->mode = GAME_SINGLE;
  91. }
  92.  
  93. void initPlayerData() {
  94.   int i;
  95.   Data *data;
  96.   AI *ai;
  97.   int not_playing = 0;
  98.  
  99.   for(i = 0; i < game->players; i++) {
  100.     data = game->player[i].data;
  101.     ai = game->player[i].ai;
  102.  
  103.     /* arrange players in circle around center */
  104.     data->iposx = game->settings->grid_size / 2 +
  105.       game->settings->grid_size / 4 *
  106.       (float) cos ( (float) (i * 2 * M_PI) / (float) game->players );
  107.  
  108.     data->iposy = game->settings->grid_size / 2 +
  109.       game->settings->grid_size / 4 * 
  110.       (float) sin ( (float) (i * 2 * M_PI) / (float) game->players );
  111.  
  112.     data->posx = data->iposx;
  113.     data->posy = data->iposy;
  114.     data->t = 0;
  115.  
  116.     /* randomize starting direction */
  117.     data->dir = rand() & 3;
  118.     data->last_dir = data->dir;
  119.     data->turn = 0;
  120.     data->turn_time = -TURN_LENGTH;
  121.  
  122.     /* if player is playing... */
  123.     if(ai->active != 2) {
  124.       data->speed = game->settings->current_speed;
  125.       data->trail_height = TRAIL_HEIGHT;
  126.       data->exp_radius = 0;
  127.     } else {
  128.       data->speed = SPEED_GONE;
  129.       data->trail_height = 0;
  130.       data->exp_radius = EXP_RADIUS_MAX;
  131.  
  132.       not_playing++;
  133.     }
  134.     data->trail = data->trails;
  135.  
  136.     data->trail->sx = data->trail->ex = data->iposx;
  137.     data->trail->sy = data->trail->ey = data->iposy;
  138.  
  139.     ai->tdiff = 0;
  140.     ai->moves = game->settings->grid_size / 10;
  141.     ai->danger = 0;
  142.     ai->lasttime = 0;
  143.   }
  144.   game->running = game->players - not_playing; /* not everyone is alive */
  145.   /* printf("starting game with %d players\n", game->running); */
  146.   game->winner = -1;
  147. }
  148.  
  149. void initData() {
  150.   int i;
  151.  
  152.   /* colmap */
  153.  
  154.   /* TODO: check if grid_size/colwidth has changed and  
  155.    *       reallocate colmap accordingly                */
  156.  
  157.   colwidth = game->settings->grid_size;
  158.   if(colmap != NULL)
  159.     free(colmap);
  160.   colmap = (unsigned char*) malloc(colwidth * game->settings->grid_size);
  161.   for(i = 0; i < colwidth * game->settings->grid_size; i++)
  162.     *(colmap + i) = 0;
  163.  
  164.   if(debugtex != NULL)
  165.     free(debugtex);
  166.   
  167.   debugtex = (unsigned char*) malloc(4 * DEBUG_TEX_W * DEBUG_TEX_H);
  168.   memset(debugtex, 0, 4 * DEBUG_TEX_W * DEBUG_TEX_H);
  169.   ogl_debugtex = 0;
  170.  
  171.   /* lasttime = SystemGetElapsedTime(); */
  172.   game->pauseflag = 0;
  173.  
  174.   game2->rules.speed = game->settings->current_speed;
  175.   game2->rules.eraseCrashed = game->settings->erase_crashed;
  176.   /* time management */
  177.   game2->time.lastFrame = 0;
  178.   game2->time.current = 0;
  179.   game2->time.offset = SystemGetElapsedTime();
  180.   /* TODO: fix that */
  181.   game2->players = game->players;
  182.   /* event management */
  183.   game2->events.next = NULL;
  184.   /* TODO: free any old events that might have gotten left */
  185.  
  186.   initPlayerData();
  187.   initClientData();
  188. }
  189.  
  190. int applyGameInfo() {
  191.   int i; 
  192.   Data *data;
  193.  
  194.   if(game2->players > game->players) {
  195.     fprintf(stderr, "more players in demo than allowed\n");
  196.     return 1;
  197.   }
  198.  
  199.   for(i = 0; i < game2->players; i++) {
  200.     data = game->player[i].data;
  201.     data->speed = game2->rules.speed;
  202.     data->iposx = game2->startPositions[3 * i + 0];
  203.     data->iposy = game2->startPositions[3 * i + 1];
  204.     data->posx = data->iposx;
  205.     data->posy = data->iposy;
  206.     data->t = 0;
  207.     data->dir = game2->startPositions[3 * i + 2];
  208.     data->last_dir = data->dir;
  209.   }
  210.  
  211.   for(; i < game->players; i++) {
  212.     data = game->player[i].data;
  213.     data->speed = SPEED_GONE;
  214.     data->trail_height = 0;
  215.     data->exp_radius = EXP_RADIUS_MAX;
  216.   }
  217.   return 0;
  218. }
  219.  
  220. int updateTime() {
  221.   game2->time.lastFrame = game2->time.current;
  222.   game2->time.current = SystemGetElapsedTime() - game2->time.offset;
  223.   game2->time.dt = game2->time.current - game2->time.lastFrame;
  224.   /* fprintf(stderr, "dt: %d\n", game2->time.dt); */
  225.   return game2->time.dt;
  226. }
  227.  
  228. void addList(list **l, void* data) {
  229.   list *p;
  230.   if(*l == NULL) {
  231.     *l = (list*) malloc(sizeof(list));
  232.     (*l)->next = NULL;
  233.   }
  234.   for(p = *l; p->next != NULL; p = p->next);
  235.   p->next = (list*) malloc(sizeof(list));
  236.   p->next->next = NULL;
  237.   p->data = data;
  238. }
  239.  
  240. void resetScores() {
  241.   int i;
  242.   for(i = 0; i < game->players; i++)
  243.     game->player[i].data->score = 0;
  244. }
  245.  
  246. void moveStep(Data* data) {
  247.   data->iposx += dirsX[data->dir];
  248.   data->iposy += dirsY[data->dir];
  249. }
  250.  
  251. void clearTrail(int player) {
  252.   int i;
  253.  
  254.   for(i = 0; i < colwidth * game->settings->grid_size; i++)
  255.     if(colmap[i] == player + 1)
  256.       colmap[i] = 0;
  257.  
  258.   rebuildDebugTex();
  259. }
  260.  
  261. void crashPlayer(int player) {
  262.   int j;
  263.  
  264. #ifdef SOUND
  265.   playCrashSound(0, player);
  266. #endif
  267.  
  268.   for(j = 0; j < game->players; j++) 
  269.     if(j != player && game->player[j].data->speed > 0)
  270.       game->player[j].data->score++;
  271.  
  272.   game->player[player].data->speed = SPEED_CRASHED;
  273.  
  274.   if(game2->rules.eraseCrashed == 1)
  275.     clearTrail(player);
  276. }
  277.  
  278. void writePosition(int player) {
  279.   unsigned char *source;
  280.   int x, y;
  281.   float tx, ty;
  282.  
  283.   x = game->player[player].data->iposx;
  284.   y = game->player[player].data->iposy;
  285.  
  286.   /* collision detection */
  287.   colmap[ y * colwidth + x ] = player + 1;
  288.  
  289.   /* debug texture */
  290.   source = debugcolors[ colmap [ y * colwidth + x ] ];
  291.   tx = (float) x * DEBUG_TEX_W / game->settings->grid_size;
  292.   ty = (float) y * DEBUG_TEX_H / game->settings->grid_size;
  293.   memcpy(debugtex + (int)ty * DEBUG_TEX_W * 4 + (int)tx * 4, source, 4);
  294. }
  295.  
  296. void newTrail(Data* data) {
  297.   line *new;
  298.  
  299.   data->trail->ex = data->iposx;
  300.   data->trail->ey = data->iposy;
  301.  
  302.   new = data->trail + 1; /* new line */
  303.  
  304.   new->sx = data->iposx;
  305.   new->sy = data->iposy;
  306.  
  307.   data->trail = new;
  308. }
  309.       
  310. void doTurn(Data *data, int time) {
  311.   newTrail(data);
  312.   data->last_dir = data->dir;
  313.   data->dir = (data->dir + data->turn) % 4;
  314.   data->turn = 0;
  315.   data->turn_time = game2->time.current;
  316.   data->posx = data->iposx + data->t * dirsX[data->dir];
  317.   data->posy = data->iposy + data->t * dirsY[data->dir];
  318. }
  319.